'use strict';

module.exports = (app) => {
  class ProfileService extends app.Service {
    async edit() {
      const { app, ctx } = this;
      const { User } = app.model.Tables.Blog;
      let profileData = ctx.request.body;
      let token = ctx.get('authorization');

      /** 数据库更新 */
      try {
        /** 解码token，获取用户信息 */
        let decode = app.jwt.decode(token);

        await User.update(profileData, {
          where: {
            id: ctx.userInfo.id,
          },
        });
        return '修改成功';
      } catch (error) {
        return error;
      }
    }

    async reset() {
      // 解构赋值
      const { app, ctx } = this;
      // 获取数据表
      const { User } = app.model.Tables.Blog;
      //获取前端传过来的参数
      let profileData = ctx.request.body;
      // 获取token
      let token = ctx.get('authorization');

      /** 解码token，获取用户信息 */
      let decode = app.jwt.decode(token);

      /** 数据库操作 */
      try {
        /** 旧密码验证 先根据解密token后得到的id查找到对应用户的密码 */
        const userInfo = await User.findAll({
          where: {
            id: ctx.userInfo.id,
          },
          attributes: ['password'],
        });
        /** 使用bcrypto自带的compare方法来进行验证 */
        const checkRes = await ctx.compare(
          profileData.passwordOld,
          userInfo[0].password
        );
        if (!checkRes) {
          return '密码验证失败';
        }

        /** 加密新密码 */
        const password = await ctx.genHash(profileData.passwordNew);

        /** 数据库更新密码 */
        let resetRes = await User.update(
          {
            password,
          },
          {
            where: {
              id: ctx.userInfo.id,
            },
          }
        );

        /** 值为1时，代表插入成功，为0则是找不到对应的旧密码 */
        if (resetRes[0] === 1) {
          // 计算token
          const token = ctx.helper.getToken({
            id: ctx.userInfo.id,
          });
          return { token };
        } else {
          return resetRes;
        }
      } catch (error) {
        console.log(error);
        return error;
      }
    }
    //获取用户信息
    async get() {
      const { app, ctx } = this;
      const { User } = app.model.Tables.Blog;
      const id = ctx.params.id;
      let attributes = [
        'id',
        'avatar',
        'desc',
        'alias',
        'followAuthor',
        'fans',
      ];
      let decode;

      try {
        /** 判断是否为已登陆的用户进行请求 */
        if (ctx.request.header.authorization) {
          decode = app.jwt.decode(ctx.get('authorization'));
          /** 用户请求的ID是否为自己的ID，如果是，则添加点赞历史和访问历史  */
          if (id == ctx.userInfo.id) {
            attributes.push('likes', 'history');
          }
        }

        const res = await User.findAll({
          where: {
            id: id,
          },
          attributes: attributes,
        });

        if (!res.length) {
          return '找不到该用户';
        }

        return res;
      } catch (error) {
        return error;
      }
    }

    async follow() {
      // 解构赋值
      const { app, ctx } = this;
      // 获取数据表
      const { User } = app.model.Tables.Blog;
      //获取前端传过来的参数
      let data = ctx.params;
      // 获取token
      let token = ctx.get('authorization');

      /** 解码token，获取用户信息 */
      let decode = app.jwt.decode(token);
      //查找作者
      let author = await User.findOne({
        where: {
          id: data.id,
        },
      });
      if (!author) {
        return '该作者不存在';
      }

      // 获取粉丝列表
      let fans = [];
      if (author.dataValues.fans.length != 0) {
        fans = author.dataValues.fans.split(',');
      }
      fans = fans.map((item) => {
        return (item = Number(item));
      });

      //如果已关注则取消关注
      if (fans.includes(ctx.userInfo.id)) {
        //从粉丝列表中移除
        fans.splice(fans.indexOf(ctx.userInfo.id), 1);
        //更新到数据库
        await User.update(
          {
            fans: fans.join(','),
          },
          {
            where: {
              id: data.id,
            },
          }
        );
        //从用户关注列表删除作者
        let followRes = await User.findByPk(ctx.userInfo.id);
        let followAuthor = followRes.dataValues.fans.split(',');
        followAuthor.splice(followAuthor.indexOf(data.id), 1);
        //更新到数据库
        await User.update(
          {
            followAuthor: followAuthor.join(','),
          },
          {
            where: {
              id: ctx.userInfo.id,
            },
          }
        );
        return '取消关注成功';
      } else {
        //未关注则关注
        //push进粉丝列表
        fans.push(ctx.userInfo.id);
        //更新到数据库
        await User.update(
          {
            fans: fans.join(','),
          },
          {
            where: {
              id: data.id,
            },
          }
        );
        // 在用户关注列表中添加作者
        let followRes = await User.findByPk(ctx.userInfo.id);
        let followAuthor = followRes.dataValues.followAuthor.split(',');
        if (!followRes.dataValues.followAuthor.length) {
          followAuthor = [];
        }
        followAuthor.push(data.id);
        //更新到数据库
        await User.update(
          {
            followAuthor: followAuthor.join(','),
          },
          {
            where: {
              id: ctx.userInfo.id,
            },
          }
        );
        return '关注成功';
      }
    }
  }
  return ProfileService;
};
